
#include "packet_types.h"

token::token(int priority, bool monitor, int reservation)
{
    // set priority
    ac.ppp = priority;
    ac.t = 0;
    ac.m = monitor;
    ac.rrr = reservation;    
}

token *token::clone()
{
    return new token(*this);
}

bool token::equals_packet(const packet& pkt)
{
    const token *test = dynamic_cast<const token *>(&pkt);                                

    return test!=0 ? equals_token(*test) : false;
}

bool token::equals_token(const token& pkt)
{
    return (sd==pkt.sd && ac==pkt.ac && ed==pkt.ed);
} 

frame *frame::clone()
{
    return new frame(*this);
}

bool frame::equals_packet(const packet& pkt)
{
    const frame *test = dynamic_cast<const frame *>(&pkt);                                

    return test!=0 ? equals_frame(*test) : false;
}

bool frame::equals_frame(const frame& pkt)
{        
    bool result = sd==pkt.sd && ac==pkt.ac && fc==pkt.fc && fcs==pkt.fcs && 
                  fs==pkt.fs && ed==pkt.ed && ri.size()==pkt.ri.size() && 
                  data.size()==pkt.data.size() && sa==pkt.sa && da==pkt.da;
    
    if (result)
    {                                       
        for (int i=0; i<ri.size(); ++i)
            if (!( result = result && (ri[i]==pkt.ri[i] )))
                break;
        
        for (int i=0; i<data.size(); ++i)
            if (!( result = result && (data[i]==pkt.data[i] )))
                break;
    }    
    
    return result;                                
}

abort_seq *abort_seq::clone()
{
    return new abort_seq(*this);
}

bool abort_seq::equals_packet(const packet& pkt)
{
    const abort_seq *test = dynamic_cast<const abort_seq *>(&pkt);                                

    return test!=0 ? equals_abort_seq(*test) : false;
}

bool abort_seq::equals_abort_seq(const abort_seq& pkt)
{
    return sd==pkt.sd && ed==pkt.ed;
}
